<?php
/**
 * Zend Framework
 *
 * LICENSE
 *
 * This source file is subject to the new BSD license that is bundled
 * with this package in the file LICENSE.txt.
 * It is also available through the world-wide-web at this URL:
 * http://framework.zend.com/license/new-bsd
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@zend.com so we can send you a copy immediately.
 *
 * @category   Zend
 * @package    Zend_Db
 * @subpackage Table
 * @copyright  Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 * @version    $Id: Abstract.php 17822 2009-08-26 00:03:56Z ralph $
 */

/**
 * @see Zend_Db_Adapter_Abstract
 */
// require_once 'Zend/Db/Adapter/Abstract.php';

/**
 * @see Zend_Db_Adapter_Abstract
 */
// require_once 'Zend/Db/Select.php';

/**
 * @see Zend_Db
 */
// require_once 'Zend/Db.php';

/**
 * Class for SQL table interface.
 *
 * @category   Zend
 * @package    Zend_Db
 * @subpackage Table
 * @copyright  Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 */
abstract class Zend_Db_Table_Abstract
{

  const ADAPTER = 'db';
  const DEFINITION = 'definition';
  const DEFINITION_CONFIG_NAME = 'definitionConfigName';
  const SCHEMA = 'schema';
  const NAME = 'name';
  const PRIMARY = 'primary';
  const COLS = 'cols';
  const METADATA = 'metadata';
  const METADATA_CACHE = 'metadataCache';
  const METADATA_CACHE_IN_CLASS = 'metadataCacheInClass';
  const ROW_CLASS = 'rowClass';
  const ROWSET_CLASS = 'rowsetClass';
  const REFERENCE_MAP = 'referenceMap';
  const DEPENDENT_TABLES = 'dependentTables';
  const SEQUENCE = 'sequence';

  const COLUMNS = 'columns';
  const REF_TABLE_CLASS = 'refTableClass';
  const REF_COLUMNS = 'refColumns';
  const ON_DELETE = 'onDelete';
  const ON_UPDATE = 'onUpdate';

  const CASCADE = 'cascade';
  const RESTRICT = 'restrict';
  const SET_NULL = 'setNull';

  const DEFAULT_NONE = 'defaultNone';
  const DEFAULT_CLASS = 'defaultClass';
  const DEFAULT_DB = 'defaultDb';

  const SELECT_WITH_FROM_PART = true;
  const SELECT_WITHOUT_FROM_PART = false;

  /**
   * Default Zend_Db_Adapter_Abstract object.
   *
   * @var Zend_Db_Adapter_Abstract
   */
  protected static $_defaultDb;

  /**
   * Optional Zend_Db_Table_Definition object
   *
   * @var unknown_type
   */
  protected $_definition = null;

  /**
   * Optional definition config name used in concrete implementation
   *
   * @var string
   */
  protected $_definitionConfigName = null;

  /**
   * Default cache for information provided by the adapter's describeTable() method.
   *
   * @var Zend_Cache_Core
   */
  protected static $_defaultMetadataCache = null;

  /**
   * Zend_Db_Adapter_Abstract object.
   *
   * @var Zend_Db_Adapter_Abstract
   */
  protected $_db;

  /**
   * The schema name (default null means current schema)
   *
   * @var array
   */
  protected $_schema = null;

  /**
   * The table name.
   *
   * @var string
   */
  protected $_name = null;

  /**
   * The table column names derived from Zend_Db_Adapter_Abstract::describeTable().
   *
   * @var array
   */
  protected $_cols;

  /**
   * The primary key column or columns.
   * A compound key should be declared as an array.
   * You may declare a single-column primary key
   * as a string.
   *
   * @var mixed
   */
  protected $_primary = null;

  /**
   * If your primary key is a compound key, and one of the columns uses
   * an auto-increment or sequence-generated value, set _identity
   * to the ordinal index in the $_primary array for that column.
   * Note this index is the position of the column in the primary key,
   * not the position of the column in the table.  The primary key
   * array is 1-based.
   *
   * @var integer
   */
  protected $_identity = 1;

  /**
   * Define the logic for new values in the primary key.
   * May be a string, boolean true, or boolean false.
   *
   * @var mixed
   */
  protected $_sequence = true;

  /**
   * Information provided by the adapter's describeTable() method.
   *
   * @var array
   */
  protected $_metadata = array();

  /**
   * Cache for information provided by the adapter's describeTable() method.
   *
   * @var Zend_Cache_Core
   */
  protected $_metadataCache = null;

  /**
   * Flag: whether or not to cache metadata in the class
   * @var bool
   */
  protected $_metadataCacheInClass = true;

  /**
   * Classname for row
   *
   * @var string
   */
  protected $_rowClass = 'Zend_Db_Table_Row';

  /**
   * Classname for rowset
   *
   * @var string
   */
  protected $_rowsetClass = 'Zend_Db_Table_Rowset';

  /**
   * Associative array map of declarative referential integrity rules.
   * This array has one entry per foreign key in the current table.
   * Each key is a mnemonic name for one reference rule.
   *
   * Each value is also an associative array, with the following keys:
   * - columns       = array of names of column(s) in the child table.
   * - refTableClass = class name of the parent table.
   * - refColumns    = array of names of column(s) in the parent table,
   *                   in the same order as those in the 'columns' entry.
   * - onDelete      = "cascade" means that a delete in the parent table also
   *                   causes a delete of referencing rows in the child table.
   * - onUpdate      = "cascade" means that an update of primary key values in
   *                   the parent table also causes an update of referencing
   *                   rows in the child table.
   *
   * @var array
   */
  protected $_referenceMap = array();

  /**
   * Simple array of class names of tables that are "children" of the current
   * table, in other words tables that contain a foreign key to this one.
   * Array elements are not table names; they are class names of classes that
   * extend Zend_Db_Table_Abstract.
   *
   * @var array
   */
  protected $_dependentTables = array();


  protected $_defaultSource = self::DEFAULT_NONE;
  protected $_defaultValues = array();

  /**
   * Constructor.
   *
   * Supported params for $config are:
   * - db              = user-supplied instance of database connector,
   *                     or key name of registry instance.
   * - name            = table name.
   * - primary         = string or array of primary key(s).
   * - rowClass        = row class name.
   * - rowsetClass     = rowset class name.
   * - referenceMap    = array structure to declare relationship
   *                     to parent tables.
   * - dependentTables = array of child tables.
   * - metadataCache   = cache for information from adapter describeTable().
   *
   * @param  mixed $config Array of user-specified config options, or just the Db Adapter.
   * @return void
   */
  public function __construct($config = array())
  {
    /**
     * Allow a scalar argument to be the Adapter object or Registry key.
     */
    if (!is_array($config)) {
      $config = array(self::ADAPTER => $config);
    }

    if ($config) {
      $this->setOptions($config);
    }

    $this->_setup();
    $this->init();
  }

  /**
   * setOptions()
   *
   * @param array $options
   * @return Zend_Db_Table_Abstract
   */
  public function setOptions(Array $options)
  {
    foreach ($options as $key => $value) {
      switch ($key) {
        case self::ADAPTER:
          $this->_setAdapter($value);
          break;
        case self::DEFINITION:
          $this->setDefinition($value);
          break;
        case self::DEFINITION_CONFIG_NAME:
          $this->setDefinitionConfigName($value);
          break;
        case self::SCHEMA:
          $this->_schema = (string)$value;
          break;
        case self::NAME:
          $this->_name = (string)$value;
          break;
        case self::PRIMARY:
          $this->_primary = (array)$value;
          break;
        case self::ROW_CLASS:
          $this->setRowClass($value);
          break;
        case self::ROWSET_CLASS:
          $this->setRowsetClass($value);
          break;
        case self::REFERENCE_MAP:
          $this->setReferences($value);
          break;
        case self::DEPENDENT_TABLES:
          $this->setDependentTables($value);
          break;
        case self::METADATA_CACHE:
          $this->_setMetadataCache($value);
          break;
        case self::METADATA_CACHE_IN_CLASS:
          $this->setMetadataCacheInClass($value);
          break;
        case self::SEQUENCE:
          $this->_setSequence($value);
          break;
        default:
          // ignore unrecognized configuration directive
          break;
      }
    }

    return $this;
  }

  /**
   * setDefinition()
   *
   * @param Zend_Db_Table_Definition $definition
   * @return Zend_Db_Table_Abstract
   */
  public function setDefinition(Zend_Db_Table_Definition $definition)
  {
    $this->_definition = $definition;
    return $this;
  }

  /**
   * getDefinition()
   *
   * @return Zend_Db_Table_Definition|null
   */
  public function getDefinition()
  {
    return $this->_definition;
  }

  /**
   * setDefinitionConfigName()
   *
   * @param string $definition
   * @return Zend_Db_Table_Abstract
   */
  public function setDefinitionConfigName($definitionConfigName)
  {
    $this->_definitionConfigName = $definitionConfigName;
    return $this;
  }

  /**
   * getDefinitionConfigName()
   *
   * @return string
   */
  public function getDefinitionConfigName()
  {
    return $this->_definitionConfigName;
  }

  /**
   * @param  string $classname
   * @return Zend_Db_Table_Abstract Provides a fluent interface
   */
  public function setRowClass($classname)
  {
    $this->_rowClass = (string)$classname;

    return $this;
  }

  /**
   * @return string
   */
  public function getRowClass()
  {
    return $this->_rowClass;
  }

  /**
   * @param  string $classname
   * @return Zend_Db_Table_Abstract Provides a fluent interface
   */
  public function setRowsetClass($classname)
  {
    $this->_rowsetClass = (string)$classname;

    return $this;
  }

  /**
   * @return string
   */
  public function getRowsetClass()
  {
    return $this->_rowsetClass;
  }

  /**
   * Add a reference to the reference map
   *
   * @param string $ruleKey
   * @param string|array $columns
   * @param string $refTableClass
   * @param string|array $refColumns
   * @param string $onDelete
   * @param string $onUpdate
   * @return Zend_Db_Table_Abstract
   */
  public function addReference($ruleKey, $columns, $refTableClass, $refColumns,
                               $onDelete = null, $onUpdate = null)
  {
    $reference = array(self::COLUMNS => (array)$columns,
      self::REF_TABLE_CLASS => $refTableClass,
      self::REF_COLUMNS => (array)$refColumns);

    if (!empty($onDelete)) {
      $reference[self::ON_DELETE] = $onDelete;
    }

    if (!empty($onUpdate)) {
      $reference[self::ON_UPDATE] = $onUpdate;
    }

    $this->_referenceMap[$ruleKey] = $reference;

    return $this;
  }

  /**
   * @param array $referenceMap
   * @return Zend_Db_Table_Abstract Provides a fluent interface
   */
  public function setReferences(array $referenceMap)
  {
    $this->_referenceMap = $referenceMap;

    return $this;
  }

  /**
   * @param string $tableClassname
   * @param string $ruleKey OPTIONAL
   * @return array
   * @throws Zend_Db_Table_Exception
   */
  public function getReference($tableClassname, $ruleKey = null)
  {
    $thisClass = get_class($this);
    if ($thisClass === 'Zend_Db_Table') {
      $thisClass = $this->_definitionConfigName;
    }
    $refMap = $this->_getReferenceMapNormalized();
    if ($ruleKey !== null) {
      if (!isset($refMap[$ruleKey])) {
        // require_once "Zend/Db/Table/Exception.php";
        throw new Zend_Db_Table_Exception("No reference rule \"$ruleKey\" from table $thisClass to table $tableClassname");
      }
      if ($refMap[$ruleKey][self::REF_TABLE_CLASS] != $tableClassname) {
        // require_once "Zend/Db/Table/Exception.php";
        throw new Zend_Db_Table_Exception("Reference rule \"$ruleKey\" does not reference table $tableClassname");
      }
      return $refMap[$ruleKey];
    }
    foreach ($refMap as $reference) {
      if ($reference[self::REF_TABLE_CLASS] == $tableClassname) {
        return $reference;
      }
    }
    // require_once "Zend/Db/Table/Exception.php";
    throw new Zend_Db_Table_Exception("No reference from table $thisClass to table $tableClassname");
  }

  /**
   * @param  array $dependentTables
   * @return Zend_Db_Table_Abstract Provides a fluent interface
   */
  public function setDependentTables(array $dependentTables)
  {
    $this->_dependentTables = $dependentTables;

    return $this;
  }

  /**
   * @return array
   */
  public function getDependentTables()
  {
    return $this->_dependentTables;
  }

  /**
   * set the defaultSource property - this tells the table class where to find default values
   *
   * @param string $defaultSource
   * @return Zend_Db_Table_Abstract
   */
  public function setDefaultSource($defaultSource = self::DEFAULT_NONE)
  {
    if (!in_array($defaultSource, array(self::DEFAULT_CLASS, self::DEFAULT_DB, self::DEFAULT_NONE))) {
      $defaultSource = self::DEFAULT_NONE;
    }

    $this->_defaultSource = $defaultSource;
    return $this;
  }

  /**
   * returns the default source flag that determines where defaultSources come from
   *
   * @return unknown
   */
  public function getDefaultSource()
  {
    return $this->_defaultSource;
  }

  /**
   * set the default values for the table class
   *
   * @param array $defaultValues
   * @return Zend_Db_Table_Abstract
   */
  public function setDefaultValues(Array $defaultValues)
  {
    foreach ($defaultValues as $defaultName => $defaultValue) {
      if (array_key_exists($defaultName, $this->_metadata)) {
        $this->_defaultValues[$defaultName] = $defaultValue;
      }
    }
    return $this;
  }

  public function getDefaultValues()
  {
    return $this->_defaultValues;
  }


  /**
   * Sets the default Zend_Db_Adapter_Abstract for all Zend_Db_Table objects.
   *
   * @param  mixed $db Either an Adapter object, or a string naming a Registry key
   * @return void
   */
  public static function setDefaultAdapter($db = null)
  {
    self::$_defaultDb = self::_setupAdapter($db);
  }

  /**
   * Gets the default Zend_Db_Adapter_Abstract for all Zend_Db_Table objects.
   *
   * @return Zend_Db_Adapter_Abstract or null
   */
  public static function getDefaultAdapter()
  {
    return self::$_defaultDb;
  }

  /**
   * @param  mixed $db Either an Adapter object, or a string naming a Registry key
   * @return Zend_Db_Table_Abstract Provides a fluent interface
   */
  protected function _setAdapter($db)
  {
    $this->_db = self::_setupAdapter($db);
    return $this;
  }

  /**
   * Gets the Zend_Db_Adapter_Abstract for this particular Zend_Db_Table object.
   *
   * @return Zend_Db_Adapter_Abstract
   */
  public function getAdapter()
  {
    return $this->_db;
  }

  /**
   * @param  mixed $db Either an Adapter object, or a string naming a Registry key
   * @return Zend_Db_Adapter_Abstract
   * @throws Zend_Db_Table_Exception
   */
  protected static function _setupAdapter($db)
  {
    if ($db === null) {
      return null;
    }
    if (is_string($db)) {
      // require_once 'Zend/Registry.php';
      $db = Zend_Registry::get($db);
    }
    if (!$db instanceof Zend_Db_Adapter_Abstract) {
      // require_once 'Zend/Db/Table/Exception.php';
      throw new Zend_Db_Table_Exception('Argument must be of type Zend_Db_Adapter_Abstract, or a Registry key where a Zend_Db_Adapter_Abstract object is stored');
    }
    return $db;
  }

  /**
   * Sets the default metadata cache for information returned by Zend_Db_Adapter_Abstract::describeTable().
   *
   * If $defaultMetadataCache is null, then no metadata cache is used by default.
   *
   * @param  mixed $metadataCache Either a Cache object, or a string naming a Registry key
   * @return void
   */
  public static function setDefaultMetadataCache($metadataCache = null)
  {
    self::$_defaultMetadataCache = self::_setupMetadataCache($metadataCache);
  }

  /**
   * Gets the default metadata cache for information returned by Zend_Db_Adapter_Abstract::describeTable().
   *
   * @return Zend_Cache_Core or null
   */
  public static function getDefaultMetadataCache()
  {
    return self::$_defaultMetadataCache;
  }

  /**
   * Sets the metadata cache for information returned by Zend_Db_Adapter_Abstract::describeTable().
   *
   * If $metadataCache is null, then no metadata cache is used. Since there is no opportunity to reload metadata
   * after instantiation, this method need not be public, particularly because that it would have no effect
   * results in unnecessary API complexity. To configure the metadata cache, use the metadataCache configuration
   * option for the class constructor upon instantiation.
   *
   * @param  mixed $metadataCache Either a Cache object, or a string naming a Registry key
   * @return Zend_Db_Table_Abstract Provides a fluent interface
   */
  protected function _setMetadataCache($metadataCache)
  {
    $this->_metadataCache = self::_setupMetadataCache($metadataCache);
    return $this;
  }

  /**
   * Gets the metadata cache for information returned by Zend_Db_Adapter_Abstract::describeTable().
   *
   * @return Zend_Cache_Core or null
   */
  public function getMetadataCache()
  {
    return $this->_metadataCache;
  }

  /**
   * Indicate whether metadata should be cached in the class for the duration
   * of the instance
   *
   * @param  bool $flag
   * @return Zend_Db_Table_Abstract
   */
  public function setMetadataCacheInClass($flag)
  {
    $this->_metadataCacheInClass = (bool)$flag;
    return $this;
  }

  /**
   * Retrieve flag indicating if metadata should be cached for duration of
   * instance
   *
   * @return bool
   */
  public function metadataCacheInClass()
  {
    return $this->_metadataCacheInClass;
  }

  /**
   * @param mixed $metadataCache Either a Cache object, or a string naming a Registry key
   * @return Zend_Cache_Core
   * @throws Zend_Db_Table_Exception
   */
  protected static function _setupMetadataCache($metadataCache)
  {
    if ($metadataCache === null) {
      return null;
    }
    if (is_string($metadataCache)) {
      // require_once 'Zend/Registry.php';
      $metadataCache = Zend_Registry::get($metadataCache);
    }
    if (!$metadataCache instanceof Zend_Cache_Core) {
      // require_once 'Zend/Db/Table/Exception.php';
      throw new Zend_Db_Table_Exception('Argument must be of type Zend_Cache_Core, or a Registry key where a Zend_Cache_Core object is stored');
    }
    return $metadataCache;
  }

  /**
   * Sets the sequence member, which defines the behavior for generating
   * primary key values in new rows.
   * - If this is a string, then the string names the sequence object.
   * - If this is boolean true, then the key uses an auto-incrementing
   *   or identity mechanism.
   * - If this is boolean false, then the key is user-defined.
   *   Use this for natural keys, for example.
   *
   * @param mixed $sequence
   * @return Zend_Db_Table_Adapter_Abstract Provides a fluent interface
   */
  protected function _setSequence($sequence)
  {
    $this->_sequence = $sequence;

    return $this;
  }

  /**
   * Turnkey for initialization of a table object.
   * Calls other protected methods for individual tasks, to make it easier
   * for a subclass to override part of the setup logic.
   *
   * @return void
   */
  protected function _setup()
  {
    $this->_setupDatabaseAdapter();
    $this->_setupTableName();
  }

  /**
   * Initialize database adapter.
   *
   * @return void
   */
  protected function _setupDatabaseAdapter()
  {
    if (!$this->_db) {
      $this->_db = self::getDefaultAdapter();
      if (!$this->_db instanceof Zend_Db_Adapter_Abstract) {
        // require_once 'Zend/Db/Table/Exception.php';
        throw new Zend_Db_Table_Exception('No adapter found for ' . get_class($this));
      }
    }
  }

  /**
   * Initialize table and schema names.
   *
   * If the table name is not set in the class definition,
   * use the class name itself as the table name.
   *
   * A schema name provided with the table name (e.g., "schema.table") overrides
   * any existing value for $this->_schema.
   *
   * @return void
   */
  protected function _setupTableName()
  {
    if (!$this->_name) {
      $this->_name = get_class($this);
    } else if (strpos($this->_name, '.')) {
      list($this->_schema, $this->_name) = explode('.', $this->_name);
    }
  }

  /**
   * Initializes metadata.
   *
   * If metadata cannot be loaded from cache, adapter's describeTable() method is called to discover metadata
   * information. Returns true if and only if the metadata are loaded from cache.
   *
   * @return boolean
   * @throws Zend_Db_Table_Exception
   */
  protected function _setupMetadata()
  {
    if ($this->metadataCacheInClass() && (count($this->_metadata) > 0)) {
      return true;
    }

    // Assume that metadata will be loaded from cache
    $isMetadataFromCache = true;

    // If $this has no metadata cache but the class has a default metadata cache
    if (null === $this->_metadataCache && null !== self::$_defaultMetadataCache) {
      // Make $this use the default metadata cache of the class
      $this->_setMetadataCache(self::$_defaultMetadataCache);
    }

    // If $this has a metadata cache
    if (null !== $this->_metadataCache) {
      // Define the cache identifier where the metadata are saved

      //get db configuration
      $dbConfig = $this->_db->getConfig();

      // Define the cache identifier where the metadata are saved
      $cacheId = md5( // port:host/dbname:schema.table (based on availabilty)
        (isset($dbConfig['options']['port']) ? ':' . $dbConfig['options']['port'] : null)
        . (isset($dbConfig['options']['host']) ? ':' . $dbConfig['options']['host'] : null)
        . '/' . $dbConfig['dbname'] . ':' . $this->_schema . '.' . $this->_name
      );
    }

    // If $this has no metadata cache or metadata cache misses
    if (null === $this->_metadataCache || !($metadata = $this->_metadataCache->load($cacheId))) {
      // Metadata are not loaded from cache
      $isMetadataFromCache = false;
      // Fetch metadata from the adapter's describeTable() method
      $metadata = $this->_db->describeTable($this->_name, $this->_schema);
      // If $this has a metadata cache, then cache the metadata
      if (null !== $this->_metadataCache && !$this->_metadataCache->save($metadata, $cacheId)) {
        /**
         * @see Zend_Db_Table_Exception
         */
        // require_once 'Zend/Db/Table/Exception.php';
        throw new Zend_Db_Table_Exception('Failed saving metadata to metadataCache');
      }
    }

    // Assign the metadata to $this
    $this->_metadata = $metadata;

    // Return whether the metadata were loaded from cache
    return $isMetadataFromCache;
  }

  /**
   * Retrieve table columns
   *
   * @return array
   */
  protected function _getCols()
  {
    if (null === $this->_cols) {
      $this->_setupMetadata();
      $this->_cols = array_keys($this->_metadata);
    }
    return $this->_cols;
  }

  /**
   * Initialize primary key from metadata.
   * If $_primary is not defined, discover primary keys
   * from the information returned by describeTable().
   *
   * @return void
   * @throws Zend_Db_Table_Exception
   */
  protected function _setupPrimaryKey()
  {
    if (!$this->_primary) {
      $this->_setupMetadata();
      $this->_primary = array();
      foreach ($this->_metadata as $col) {
        if ($col['PRIMARY']) {
          $this->_primary[$col['PRIMARY_POSITION']] = $col['COLUMN_NAME'];
          if ($col['IDENTITY']) {
            $this->_identity = $col['PRIMARY_POSITION'];
          }
        }
      }
      // if no primary key was specified and none was found in the metadata
      // then throw an exception.
      if (empty($this->_primary)) {
        // require_once 'Zend/Db/Table/Exception.php';
        throw new Zend_Db_Table_Exception('A table must have a primary key, but none was found');
      }
    } else if (!is_array($this->_primary)) {
      $this->_primary = array(1 => $this->_primary);
    } else if (isset($this->_primary[0])) {
      array_unshift($this->_primary, null);
      unset($this->_primary[0]);
    }

    $cols = $this->_getCols();
    if (!array_intersect((array)$this->_primary, $cols) == (array)$this->_primary) {
      // require_once 'Zend/Db/Table/Exception.php';
      throw new Zend_Db_Table_Exception("Primary key column(s) ("
      . implode(',', (array)$this->_primary)
      . ") are not columns in this table ("
      . implode(',', $cols)
      . ")");
    }

    $primary = (array)$this->_primary;
    $pkIdentity = $primary[(int)$this->_identity];

    /**
     * Special case for PostgreSQL: a SERIAL key implicitly uses a sequence
     * object whose name is "<table>_<column>_seq".
     */
    if ($this->_sequence === true && $this->_db instanceof Zend_Db_Adapter_Pdo_Pgsql) {
      $this->_sequence = $this->_db->quoteIdentifier("{$this->_name}_{$pkIdentity}_seq");
      if ($this->_schema) {
        $this->_sequence = $this->_db->quoteIdentifier($this->_schema) . '.' . $this->_sequence;
      }
    }
  }

  /**
   * Returns a normalized version of the reference map
   *
   * @return array
   */
  protected function _getReferenceMapNormalized()
  {
    $referenceMapNormalized = array();

    foreach ($this->_referenceMap as $rule => $map) {

      $referenceMapNormalized[$rule] = array();

      foreach ($map as $key => $value) {
        switch ($key) {

          // normalize COLUMNS and REF_COLUMNS to arrays
          case self::COLUMNS:
          case self::REF_COLUMNS:
            if (!is_array($value)) {
              $referenceMapNormalized[$rule][$key] = array($value);
            } else {
              $referenceMapNormalized[$rule][$key] = $value;
            }
            break;

          // other values are copied as-is
          default:
            $referenceMapNormalized[$rule][$key] = $value;
            break;
        }
      }
    }

    return $referenceMapNormalized;
  }

  /**
   * Initialize object
   *
   * Called from {@link __construct()} as final step of object instantiation.
   *
   * @return void
   */
  public function init()
  {
  }

  /**
   * Returns table information.
   *
   * You can elect to return only a part of this information by supplying its key name,
   * otherwise all information is returned as an array.
   *
   * @param  $key The specific info part to return OPTIONAL
   * @return mixed
   */
  public function info($key = null)
  {
    $this->_setupPrimaryKey();

    $info = array(
      self::SCHEMA => $this->_schema,
      self::NAME => $this->_name,
      self::COLS => $this->_getCols(),
      self::PRIMARY => (array)$this->_primary,
      self::METADATA => $this->_metadata,
      self::ROW_CLASS => $this->getRowClass(),
      self::ROWSET_CLASS => $this->getRowsetClass(),
      self::REFERENCE_MAP => $this->_referenceMap,
      self::DEPENDENT_TABLES => $this->_dependentTables,
      self::SEQUENCE => $this->_sequence
    );

    if ($key === null) {
      return $info;
    }

    if (!array_key_exists($key, $info)) {
      // require_once 'Zend/Db/Table/Exception.php';
      throw new Zend_Db_Table_Exception('There is no table information for the key "' . $key . '"');
    }

    return $info[$key];
  }

  /**
   * Returns an instance of a Zend_Db_Table_Select object.
   *
   * @param bool $withFromPart Whether or not to include the from part of the select based on the table
   * @return Zend_Db_Table_Select
   */
  public function select($withFromPart = self::SELECT_WITHOUT_FROM_PART)
  {
    // require_once 'Zend/Db/Table/Select.php';
    $select = new Zend_Db_Table_Select($this);
    if ($withFromPart == self::SELECT_WITH_FROM_PART) {
      $select->from($this->info(self::NAME), Zend_Db_Table_Select::SQL_WILDCARD, $this->info(self::SCHEMA));
    }
    return $select;
  }

  /**
   * Inserts a new row.
   *
   * @param  array $data  Column-value pairs.
   * @return mixed         The primary key of the row inserted.
   */
  public function insert(array $data)
  {
    $this->_setupPrimaryKey();

    /**
     * Zend_Db_Table assumes that if you have a compound primary key
     * and one of the columns in the key uses a sequence,
     * it's the _first_ column in the compound key.
     */
    $primary = (array)$this->_primary;
    $pkIdentity = $primary[(int)$this->_identity];

    /**
     * If this table uses a database sequence object and the data does not
     * specify a value, then get the next ID from the sequence and add it
     * to the row.  We assume that only the first column in a compound
     * primary key takes a value from a sequence.
     */
    if (is_string($this->_sequence) && !isset($data[$pkIdentity])) {
      $data[$pkIdentity] = $this->_db->nextSequenceId($this->_sequence);
    }

    /**
     * If the primary key can be generated automatically, and no value was
     * specified in the user-supplied data, then omit it from the tuple.
     */
    if (array_key_exists($pkIdentity, $data) && $data[$pkIdentity] === null) {
      unset($data[$pkIdentity]);
    }

    /**
     * INSERT the new row.
     */
    $tableSpec = ($this->_schema ? $this->_schema . '.' : '') . $this->_name;
    $this->_db->insert($tableSpec, $data);

    /**
     * Fetch the most recent ID generated by an auto-increment
     * or IDENTITY column, unless the user has specified a value,
     * overriding the auto-increment mechanism.
     */
    if ($this->_sequence === true && !isset($data[$pkIdentity])) {
      $data[$pkIdentity] = $this->_db->lastInsertId();
    }

    /**
     * Return the primary key value if the PK is a single column,
     * else return an associative array of the PK column/value pairs.
     */
    $pkData = array_intersect_key($data, array_flip($primary));
    if (count($primary) == 1) {
      reset($pkData);
      return current($pkData);
    }

    return $pkData;
  }

  /**
   * Check if the provided column is an identity of the table
   *
   * @param  string $column
   * @throws Zend_Db_Table_Exception
   * @return boolean
   */
  public function isIdentity($column)
  {
    $this->_setupPrimaryKey();

    if (!isset($this->_metadata[$column])) {
      /**
       * @see Zend_Db_Table_Exception
       */
      // require_once 'Zend/Db/Table/Exception.php';

      throw new Zend_Db_Table_Exception('Column "' . $column . '" not found in table.');
    }

    return (bool)$this->_metadata[$column]['IDENTITY'];
  }

  /**
   * Updates existing rows.
   *
   * @param  array $data  Column-value pairs.
   * @param  array|string $where An SQL WHERE clause, or an array of SQL WHERE clauses.
   * @return int          The number of rows updated.
   */
  public function update(array $data, $where)
  {
    $tableSpec = ($this->_schema ? $this->_schema . '.' : '') . $this->_name;
    return $this->_db->update($tableSpec, $data, $where);
  }

  /**
   * Called by a row object for the parent table's class during save() method.
   *
   * @param  string $parentTableClassname
   * @param  array $oldPrimaryKey
   * @param  array $newPrimaryKey
   * @return int
   */
  public function _cascadeUpdate($parentTableClassname, array $oldPrimaryKey, array $newPrimaryKey)
  {
    $this->_setupMetadata();
    $rowsAffected = 0;
    foreach ($this->_getReferenceMapNormalized() as $map) {
      if ($map[self::REF_TABLE_CLASS] == $parentTableClassname && isset($map[self::ON_UPDATE])) {
        switch ($map[self::ON_UPDATE]) {
          case self::CASCADE:
            $newRefs = array();
            $where = array();
            for ($i = 0; $i < count($map[self::COLUMNS]); ++$i) {
              $col = $this->_db->foldCase($map[self::COLUMNS][$i]);
              $refCol = $this->_db->foldCase($map[self::REF_COLUMNS][$i]);
              if (array_key_exists($refCol, $newPrimaryKey)) {
                $newRefs[$col] = $newPrimaryKey[$refCol];
              }
              $type = $this->_metadata[$col]['DATA_TYPE'];
              $where[] = $this->_db->quoteInto(
                $this->_db->quoteIdentifier($col, true) . ' = ?',
                $oldPrimaryKey[$refCol], $type);
            }
            $rowsAffected += $this->update($newRefs, $where);
            break;
          default:
            // no action
            break;
        }
      }
    }
    return $rowsAffected;
  }

  /**
   * Deletes existing rows.
   *
   * @param  array|string $where SQL WHERE clause(s).
   * @return int          The number of rows deleted.
   */
  public function delete($where)
  {
    $tableSpec = ($this->_schema ? $this->_schema . '.' : '') . $this->_name;
    return $this->_db->delete($tableSpec, $where);
  }

  /**
   * Called by parent table's class during delete() method.
   *
   * @param  string $parentTableClassname
   * @param  array $primaryKey
   * @return int    Number of affected rows
   */
  public function _cascadeDelete($parentTableClassname, array $primaryKey)
  {
    $this->_setupMetadata();
    $rowsAffected = 0;
    foreach ($this->_getReferenceMapNormalized() as $map) {
      if ($map[self::REF_TABLE_CLASS] == $parentTableClassname && isset($map[self::ON_DELETE])) {
        switch ($map[self::ON_DELETE]) {
          case self::CASCADE:
            $where = array();
            for ($i = 0; $i < count($map[self::COLUMNS]); ++$i) {
              $col = $this->_db->foldCase($map[self::COLUMNS][$i]);
              $refCol = $this->_db->foldCase($map[self::REF_COLUMNS][$i]);
              $type = $this->_metadata[$col]['DATA_TYPE'];
              $where[] = $this->_db->quoteInto(
                $this->_db->quoteIdentifier($col, true) . ' = ?',
                $primaryKey[$refCol], $type);
            }
            $rowsAffected += $this->delete($where);
            break;
          default:
            // no action
            break;
        }
      }
    }
    return $rowsAffected;
  }

  /**
   * Fetches rows by primary key.  The argument specifies one or more primary
   * key value(s).  To find multiple rows by primary key, the argument must
   * be an array.
   *
   * This method accepts a variable number of arguments.  If the table has a
   * multi-column primary key, the number of arguments must be the same as
   * the number of columns in the primary key.  To find multiple rows in a
   * table with a multi-column primary key, each argument must be an array
   * with the same number of elements.
   *
   * The find() method always returns a Rowset object, even if only one row
   * was found.
   *
   * @param  mixed $key The value(s) of the primary keys.
   * @return Zend_Db_Table_Rowset_Abstract Row(s) matching the criteria.
   * @throws Zend_Db_Table_Exception
   */
  public function find()
  {
    $this->_setupPrimaryKey();
    $args = func_get_args();
    $keyNames = array_values((array)$this->_primary);

    if (count($args) < count($keyNames)) {
      // require_once 'Zend/Db/Table/Exception.php';
      throw new Zend_Db_Table_Exception("Too few columns for the primary key");
    }

    if (count($args) > count($keyNames)) {
      // require_once 'Zend/Db/Table/Exception.php';
      throw new Zend_Db_Table_Exception("Too many columns for the primary key");
    }

    $whereList = array();
    $numberTerms = 0;
    foreach ($args as $keyPosition => $keyValues) {
      $keyValuesCount = count($keyValues);
      // Coerce the values to an array.
      // Don't simply typecast to array, because the values
      // might be Zend_Db_Expr objects.
      if (!is_array($keyValues)) {
        $keyValues = array($keyValues);
      }
      if ($numberTerms == 0) {
        $numberTerms = $keyValuesCount;
      } else if ($keyValuesCount != $numberTerms) {
        // require_once 'Zend/Db/Table/Exception.php';
        throw new Zend_Db_Table_Exception("Missing value(s) for the primary key");
      }
      $keyValues = array_values($keyValues);
      for ($i = 0; $i < $keyValuesCount; ++$i) {
        if (!isset($whereList[$i])) {
          $whereList[$i] = array();
        }
        $whereList[$i][$keyPosition] = $keyValues[$i];
      }
    }

    $whereClause = null;
    if (count($whereList)) {
      $whereOrTerms = array();
      $tableName = $this->_db->quoteTableAs($this->_name, null, true);
      foreach ($whereList as $keyValueSets) {
        $whereAndTerms = array();
        foreach ($keyValueSets as $keyPosition => $keyValue) {
          $type = $this->_metadata[$keyNames[$keyPosition]]['DATA_TYPE'];
          $columnName = $this->_db->quoteIdentifier($keyNames[$keyPosition], true);
          $whereAndTerms[] = $this->_db->quoteInto(
            $tableName . '.' . $columnName . ' = ?',
            $keyValue, $type);
        }
        $whereOrTerms[] = '(' . implode(' AND ', $whereAndTerms) . ')';
      }
      $whereClause = '(' . implode(' OR ', $whereOrTerms) . ')';
    }

    // issue ZF-5775 (empty where clause should return empty rowset)
    if ($whereClause == null) {
      $rowsetClass = $this->getRowsetClass();
      if (!class_exists($rowsetClass)) {
        // require_once 'Zend/Loader.php';
        Zend_Loader::loadClass($rowsetClass);
      }
      return new $rowsetClass(array('table' => $this, 'rowClass' => $this->getRowClass(), 'stored' => true));
    }

    return $this->fetchAll($whereClause);
  }

  /**
   * Fetches all rows.
   *
   * Honors the Zend_Db_Adapter fetch mode.
   *
   * @param string|array|Zend_Db_Table_Select $where  OPTIONAL An SQL WHERE clause or Zend_Db_Table_Select object.
   * @param string|array $order  OPTIONAL An SQL ORDER clause.
   * @param int $count  OPTIONAL An SQL LIMIT count.
   * @param int $offset OPTIONAL An SQL LIMIT offset.
   * @return Zend_Db_Table_Rowset_Abstract The row results per the Zend_Db_Adapter fetch mode.
   */
  public function fetchAll($where = null, $order = null, $count = null, $offset = null)
  {
    if (!($where instanceof Zend_Db_Table_Select)) {
      $select = $this->select();

      if ($where !== null) {
        $this->_where($select, $where);
      }

      if ($order !== null) {
        $this->_order($select, $order);
      }

      if ($count !== null || $offset !== null) {
        $select->limit($count, $offset);
      }

    } else {
      $select = $where;
    }

    $rows = $this->_fetch($select);

    $data = array(
      'table' => $this,
      'data' => $rows,
      'readOnly' => $select->isReadOnly(),
      'rowClass' => $this->getRowClass(),
      'stored' => true
    );

    $rowsetClass = $this->getRowsetClass();
    if (!class_exists($rowsetClass)) {
      // require_once 'Zend/Loader.php';
      Zend_Loader::loadClass($rowsetClass);
    }
    return new $rowsetClass($data);
  }

  /**
   * Fetches one row in an object of type Zend_Db_Table_Row_Abstract,
   * or returns null if no row matches the specified criteria.
   *
   * @param string|array|Zend_Db_Table_Select $where  OPTIONAL An SQL WHERE clause or Zend_Db_Table_Select object.
   * @param string|array $order  OPTIONAL An SQL ORDER clause.
   * @return Zend_Db_Table_Row_Abstract|null The row results per the
   *     Zend_Db_Adapter fetch mode, or null if no row found.
   */
  public function fetchRow($where = null, $order = null)
  {
    if (!($where instanceof Zend_Db_Table_Select)) {
      $select = $this->select();

      if ($where !== null) {
        $this->_where($select, $where);
      }

      if ($order !== null) {
        $this->_order($select, $order);
      }

      $select->limit(1);

    } else {
      $select = $where->limit(1);
    }

    $rows = $this->_fetch($select);

    if (count($rows) == 0) {
      return null;
    }

    $data = array(
      'table' => $this,
      'data' => $rows[0],
      'readOnly' => $select->isReadOnly(),
      'stored' => true
    );

    $rowClass = $this->getRowClass();
    if (!class_exists($rowClass)) {
      // require_once 'Zend/Loader.php';
      Zend_Loader::loadClass($rowClass);
    }
    return new $rowClass($data);
  }

  /**
   * Fetches a new blank row (not from the database).
   *
   * @return Zend_Db_Table_Row_Abstract
   * @deprecated since 0.9.3 - use createRow() instead.
   */
  public function fetchNew()
  {
    return $this->createRow();
  }

  /**
   * Fetches a new blank row (not from the database).
   *
   * @param  array $data OPTIONAL data to populate in the new row.
   * @param  string $defaultSource OPTIONAL flag to force default values into new row
   * @return Zend_Db_Table_Row_Abstract
   */
  public function createRow(array $data = array(), $defaultSource = null)
  {
    $cols = $this->_getCols();
    $defaults = array_combine($cols, array_fill(0, count($cols), null));

    // nothing provided at call-time, take the class value
    if ($defaultSource == null) {
      $defaultSource = $this->_defaultSource;
    }

    if (!in_array($defaultSource, array(self::DEFAULT_CLASS, self::DEFAULT_DB, self::DEFAULT_NONE))) {
      $defaultSource = self::DEFAULT_NONE;
    }

    if ($defaultSource == self::DEFAULT_DB) {
      foreach ($this->_metadata as $metadataName => $metadata) {
        if (($metadata['DEFAULT'] != null) &&
          ($metadata['NULLABLE'] !== true || ($metadata['NULLABLE'] === true && isset($this->_defaultValues[$metadataName]) && $this->_defaultValues[$metadataName] === true)) &&
          (!(isset($this->_defaultValues[$metadataName]) && $this->_defaultValues[$metadataName] === false))
        ) {
          $defaults[$metadataName] = $metadata['DEFAULT'];
        }
      }
    } elseif ($defaultSource == self::DEFAULT_CLASS && $this->_defaultValues) {
      foreach ($this->_defaultValues as $defaultName => $defaultValue) {
        if (array_key_exists($defaultName, $defaults)) {
          $defaults[$defaultName] = $defaultValue;
        }
      }
    }

    $config = array(
      'table' => $this,
      'data' => $defaults,
      'readOnly' => false,
      'stored' => false
    );

    $rowClass = $this->getRowClass();
    if (!class_exists($rowClass)) {
      // require_once 'Zend/Loader.php';
      Zend_Loader::loadClass($rowClass);
    }

    $row = new $rowClass($config);
    $row->setFromArray($data);
    return $row;
  }

  /**
   * Generate WHERE clause from user-supplied string or array
   *
   * @param  string|array $where  OPTIONAL An SQL WHERE clause.
   * @return Zend_Db_Table_Select
   */
  protected function _where(Zend_Db_Table_Select $select, $where)
  {
    $where = (array)$where;

    foreach ($where as $key => $val) {
      // is $key an int?
      if (is_int($key)) {
        // $val is the full condition
        $select->where($val);
      } else {
        // $key is the condition with placeholder,
        // and $val is quoted into the condition
        $select->where($key, $val);
      }
    }

    return $select;
  }

  /**
   * Generate ORDER clause from user-supplied string or array
   *
   * @param  string|array $order  OPTIONAL An SQL ORDER clause.
   * @return Zend_Db_Table_Select
   */
  protected function _order(Zend_Db_Table_Select $select, $order)
  {
    if (!is_array($order)) {
      $order = array($order);
    }

    foreach ($order as $val) {
      $select->order($val);
    }

    return $select;
  }

  /**
   * Support method for fetching rows.
   *
   * @param  Zend_Db_Table_Select $select  query options.
   * @return array An array containing the row results in FETCH_ASSOC mode.
   */
  protected function _fetch(Zend_Db_Table_Select $select)
  {
    $stmt = $this->_db->query($select);
    $data = $stmt->fetchAll(Zend_Db::FETCH_ASSOC);
    return $data;
  }

}
